La boucle for permet de répéter des actions spécifiques un certain nombre de fois, rendant nos programmes plus puissants et plus efficaces. Imaginez que vous ayez une tâche à accomplir plusieurs fois, au lieu de répéter le même code encore et encore, la boucle for vous permet de le faire de manière ordonnée et concise.

Swift fournit plusieurs instructions de contrôle de flux. Nous avons déjà découvert les instructions if et switch pour exécuter différentes branches de code en fonction de certaines conditions. Aujourd'hui, nous allons nous intéresser à la boucle for.

Syntaxe de la boucle for

La boucle for est un outil puissant en programmation Swift qui permet de répéter des actions de manière ordonnée. Comprendre sa syntaxe est essentiel pour écrire un code efficace et lisible. Découvrons comment elle peut être utilisée pour automatiser des tâches répétitives :


for index in 1...5 {
    // Bloc de code à répéter
    print("Répétition numéro \(index)")
}

// Cela affichera :
// Répétition numéro 1
// Répétition numéro 2
// Répétition numéro 3
// Répétition numéro 4
// Répétition numéro 5
  1. Le mot-clé for qui indique le début d'une boucle for
  2. index est une variable temporaire et accessible uniquement depuis la boucle. Elle prendra successivement les valeurs spécifiées dans la plage (ici, de 1 à 5). Au premier tour, sa valeur sera de 1, au deuxième sa valeur sera de 2, ... jusqu'au cinquième et dernier tour de boucle ou sa valeur sera de 5.
  3. On utilise le mot-clé in qui sépare la variable de la plage de valeurs.
  4. La plage de valeurs (1 ... 5) représente le nombre de tours de boucle. Mais c'est aussi la valeur que la variable index prendra. Un peu plus bas dans ce chapitre, nous reparlerons des plages de valeurs.
  5. Le bloc de code entre les accolades sera répété à chaque itération de la boucle, soit 5 fois. La variable index prendra successivement les valeurs de 1 à 5.

Prenons un exemple concret : les tables de multiplications. Plutôt que de répéter 10 fois la même ligne de code, on va utiliser la boucle for qui le fera à notre place :


let nombreAMultiplier = 4

for nombre in 1...10 {
    let resultat = nombreAMultiplier * nombre
    print("\(nombre) fois \(nombreAMultiplier) est égal à \(resultat)")
}

// Cela affichera : 
// 1 fois 4 est égal à 4
// 2 fois 4 est égal à 8
// 3 fois 4 est égal à 12
// 4 fois 4 est égal à 16
// 5 fois 4 est égal à 20
// 6 fois 4 est égal à 24
// 7 fois 4 est égal à 28
// 8 fois 4 est égal à 32
// 9 fois 4 est égal à 36
// 10 fois 4 est égal à 40

Prenons le temps de détailler le fonctionnement de la boucle for ci-dessus. Nous avons commencé par déclarer une constante nommée nombreAMultiplier . Celle-ci aura une valeur arbitraire de 4. Cela signifie qu'il s'agira de la table des 4.

Ensuite, nous ouvrons notre boucle en indiquant à Swift qu'il s'agit d'une boucle for, qu'elle contiendra une variable nommée nombre et qu'il faudra réaliser 10 tours de cette boucle. Le code entre les accolades sera donc effectué 10 fois.

Pour ce qui concerne justement ce code entre les accolades, vous devez avoir les connaissances nécessaires pour le comprendre : la constante resultat aura pour valeur le produit de la multiplication de la constante nombreAMultiplier et de la variable nombre. Cette dernière aura pour valeur 1 au premier tour de boucle, puis 2 au second tour de boucle, et ainsi de suite ...

Boucle for sans valeur spécifique

Si vous n'avez pas besoin d'utiliser une valeur spécifique à l'intérieur des accolades, on utilise le symbole undescore _ 


for _ in 1...3 {
    print("Je suis le plus fort !")
}

// Cela affichera :
// Je suis le plus fort !
// Je suis le plus fort !
// Je suis le plus fort !

Opérateurs de plage

Les opérateurs de plage Swift permettent de définir des intervalles de valeurs. Ces opérateurs sont particulièrement utiles pour les boucles et les conditions, car ils facilitent la compréhension du code en rendant les limites des intervalles explicites.

Opérateur de plage fermée

L'opérateur de plage fermée a...b définit une plage qui va de a à b et inclut les valeurs a et b. La valeur de a ne doit pas être supérieure à b.


for index in 1...5 {
    print("\(index) fois 5 est égal à \(index * 5)")
}

// Cela affichera :
// 1 fois 5 est égal à 5
// 2 fois 5 est égal à 10
// 3 fois 5 est égal à 15
// 4 fois 5 est égal à 20
// 5 fois 5 est égal à 25

Opérateur de plage semi-ouverte

L'opérateur de plage semi-ouverte définit une plage qui va de a à b, mais ne comprend pas b . On dit qu'il est à moitié ouvert car il contient sa première valeur, mais pas sa valeur finale.

Comme pour l'opérateur de plage fermée, la valeur de a ne doit pas être supérieure à b. Si la valeur de a est égale à b, la plage résultante sera vide.


for i in 1..<5 {
    print(i)
}

// Cela affichera :
// 1
// 2
// 3
// 4

Dans cet exemple, i sera une plage semi-ouverte allant de 1 à 4. La valeur 5 n'est pas incluse dans la plage. Ainsi, i contiendra les valeurs 1, 2, 3, et 4. Cette boucle for itérera sur les valeurs de 1 à 4, mais n'inclura pas la valeur 5.

Opérateur de plage unique

L'opérateur de plage unique crée une plage qui ne contient qu'une seule valeur. Cela peut être utile dans certaines situations où une plage est attendue, mais vous avez seulement besoin d'une seule valeur.


for i in 5...5 {
    print(i)
}

// Cela affichera :
// 5

Opérateur de plage réversible

Les opérateurs de plage peuvent également être utilisés de manière inversée. Par exemple, pour créer une plage décroissante, on utilise la méthode reversed() sur la plage de valeur :


for i in (1...5).reversed() {
    print(i)
}

// Cela affichera :
// 5
// 4
// 3
// 2
// 1
Nous aborderons le sujet des méthodes dans quelques chapitres. Mais rappelez-vous, vous en avez déjà entendu parler. C'était dans le chapitre sur les chaînes de caractères avec la méthode count.

Opérateur de plage unilatérale

En Swift, les opérateurs de plage unilatérale permettent de définir des plages avec une seule limite, soit inférieure, soit supérieure. Cela peut être utile dans certaines situations où seule une limite est connue ou nécessaire.

Plage Unilatérale Inférieure (a...)
Si vous connaissez uniquement la limite inférieure, vous pouvez créer une plage unilatérale inférieure en utilisant l'opérateur de plage fermée (...) précédée de la valeur de la limite inférieure :


let infiniPositif = 1...
// infiniPositif contient toutes les valeurs à partir de 1 jusqu'à l'infini

Plage Unilatérale Supérieure (...a)
Si vous connaissez uniquement la limite supérieure, vous pouvez créer une plage unilatérale supérieure en utilisant l'opérateur de plage fermée (...) suivie de la valeur de la limite supérieure : 


let infiniNegatif = ...0
// infiniNegatif contient toutes les valeurs de l'infini jusqu'à 5

l'utilisation de plages unilatérales avec des limites infinies nécessite une attention particulière pour éviter des boucles infinies ou des problèmes de performance.

Assurez-vous de bien comprendre le contexte d'utilisation des plages unilatérales dans votre code pour éviter des comportements inattendus.

Les plages de valeurs avec une condition Switch

Dans le chapitre précédent, nous avons vu la condition switch. Sachez que vous pouvez l'utiliser avec les opérateurs de plage. Cela vous permet de vérifier si une expression répond à une plage de valeurs :


switch expression {
  case 1...10:
    // code à exécuter si expression est compris entre 1 et 10
  case 11...20:
    // code à exécuter si expression est compris entre 11 et 20
  default:
    // code à exécuter si expression ne correspond à aucune des valeurs définies précédemment
}

Les intervalles

Le dernier point de ce chapitre concerne la méthode stride. Elle est souvent utilisée avec une boucle for pour itérer par intervalle. Voici un exemple simple pour illustrer son utilisation :


for i in stride(from: 1, to: 10, by: 2) {
    print(i)
}

// Cela affichera :
// 1
// 3
// 5
// 7
// 9

Dans cet exemple, la boucle for utilise la méthode stride pour itérer sur une séquence de nombres commençant par 1 jusqu'à 10 exclu, avec un pas de 2. À chaque itération, la variable i prend la valeur de la séquence générée par stride, et la boucle affiche ensuite la valeur actuelle.

Au premier tour de la boucle, la variable i aura pour valeur 1, au second tour elle aura pour valeur 3 car on avance par intervalle de 2 (by : 2), au troisième tour de boucle elle aura pour valeur 5, au quatrième tour sa valeur sera de 7, au cinquième tour elle sera de 9 et la boucle s'arrêtera car l'intervalle défini va de 1 à 10 exclu.

C'est très utile lorsque vous avez besoin de parcourir une séquence avec des intervalles spécifiques.

Maintenant, laissez moi vous féliciter pour cette nouvelle étape de franchie. Vos connaissances en Swift sont de plus en plus grandes ! Vous savez désormais stocker une donnée grâce aux variables, aux constantes et aux tuples mais vous savez également mettre des conditions dans votre code et maintenant vous savez faire des boucles. Gardez le rythme et soyez fier de ce que vous avez déjà accompli.

  • La boucle for permet de répéter des actions spécifiques un certain nombre de fois.
  • Si vous n'avez pas besoin d'utiliser une valeur spécifique à l'intérieur des accolades, utilisez le symbole undescore _
  • Les opérateurs de plage Swift permettent de définir des intervalles de valeurs.
  • On utilise la méthode stride pour itérer une boucle par intervalle spécifique.

Je vous conseille de faire chaque exercice de fin de chapitre. Cela consolidera votre apprentissage de manière efficace en passant de la théorie à la pratique. Faites vos propres experiences, n'ayez peur de rien, vous progresserez plus vite ainsi.

Vos connaissances étant grandissantes, il m'a fallu trouver un exercice à votre hauteur. J'espère que celui-ci va vous donner un peu de fil à retordre :

Écrivez un programme qui utilise une boucle for pour calculer la somme des nombres pairs de 1 à 20.


var total = 0

for i in stride(from: 2, to: 21, by: 2) {
    total += i
    print("+\(i) pour un total de \(total)")
}

// Cela affichera :
// +2 pour un total de 2
// +4 pour un total de 6
// +6 pour un total de 12
// +8 pour un total de 20
// +10 pour un total de 30
// +12 pour un total de 42
// +14 pour un total de 56
// +16 pour un total de 72
// +18 pour un total de 90
// +20 pour un total de 110